package org.springframework.ai.mcp.server.demo.tools;

import com.fasterxml.jackson.databind.ObjectMapper;
import io.modelcontextprotocol.server.McpServerFeatures;
import io.modelcontextprotocol.spec.McpSchema;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 小说排行榜工具配置类，提供爬取起点中文网热门小说排行榜的功能。
 */
@Configuration
public class NovelRankingTools {

    private static final Logger logger = LoggerFactory.getLogger(NovelRankingTools.class);
    private static final String QIDIAN_HOTSALES_URL = "https://www.qidian.com/rank/hotsales";
    private static final String USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36";
    private static final int TIMEOUT = 10000; // 10秒超时
    private final ObjectMapper objectMapper = new ObjectMapper();

    /**
     * 小说排行榜工具集合：包含所有小说排行榜相关的工具。
     */
    @Bean
    public List<McpServerFeatures.SyncToolSpecification> novelRankingToolList() {
        return List.of(createQidianHotSalesTool());
    }

    /**
     * 创建起点中文网热门小说排行榜工具。
     */
    private McpServerFeatures.SyncToolSpecification createQidianHotSalesTool() {
        logger.info("创建起点中文网热门小说排行榜工具");

        String schemaJson = """
        {
          "type": "object",
          "properties": {
            "limit": {
              "type": "integer",
              "description": "返回的小说数量限制，默认为10，最大为50",
              "minimum": 1,
              "maximum": 50,
              "default": 10
            }
          }
        }
        """;

        McpSchema.Tool tool = new McpSchema.Tool(
            "qidian_hotsales",
            "获取起点中文网热门小说排行榜信息",
            schemaJson
        );

        return new McpServerFeatures.SyncToolSpecification(
            tool,
            (exchange, arguments) -> {
                try {
                    Integer limit = 10; // 默认值
                    if (arguments.containsKey("limit")) {
                        Object limitValue = arguments.get("limit");
                        if (limitValue instanceof Number) {
                            limit = ((Number) limitValue).intValue();
                        } else if (limitValue instanceof String) {
                            try {
                                limit = Integer.parseInt((String) limitValue);
                            } catch (NumberFormatException e) {
                                logger.warn("无效的limit参数值: {}, 使用默认值: {}", limitValue, 10);
                            }
                        }
                        // 限制结果数量在合理范围内
                        limit = Math.max(1, Math.min(limit, 50));
                    }

                    logger.info("获取起点中文网热门小说排行榜，限制数量: {}", limit);

                    // 爬取网页内容
                    Document doc = Jsoup.connect(QIDIAN_HOTSALES_URL)
                            .userAgent(USER_AGENT)
                            .timeout(TIMEOUT)
                            .get();

                    // 解析小说排行榜
                    List<Map<String, Object>> novels = parseNovelRanking(doc, limit);

                    // 检查是否获取到了数据
                    if (novels.isEmpty()) {
                        return new McpSchema.CallToolResult("未能获取到起点中文网热门小说排行榜数据，可能是网站结构已改变或网络连接问题。请稍后再试或检查网络连接。", true);
                    }

                    // 转换为JSON字符串
                    String resultJson = objectMapper.writeValueAsString(novels);

                    String response = String.format("成功获取起点中文网热门小说排行榜！共返回 %d 条小说:\n%s",
                            novels.size(), resultJson);

                    return new McpSchema.CallToolResult(response, false);

                } catch (IOException e) {
                    logger.error("获取起点中文网热门小说排行榜失败", e);
                    return new McpSchema.CallToolResult("获取排行榜失败: " + e.getMessage(), true);
                } catch (Exception e) {
                    logger.error("处理起点中文网热门小说排行榜时发生错误", e);
                    return new McpSchema.CallToolResult("处理排行榜数据时发生错误: " + e.getMessage(), true);
                }
            }
        );
    }

    /**
     * 解析小说排行榜页面，提取小说信息。
     */
    private List<Map<String, Object>> parseNovelRanking(Document doc, int limit) {
        List<Map<String, Object>> novels = new ArrayList<>();
        
        try {
            // 根据起点中文网的HTML结构解析小说列表
            // 这里使用通用的选择器，实际可能需要根据网站结构调整
            Elements bookItems = doc.select(".rank-view-list li");
            
            if (bookItems.isEmpty()) {
                // 尝试其他可能的选择器
                bookItems = doc.select(".book-list li");
            }
            
            if (bookItems.isEmpty()) {
                // 再尝试其他可能的选择器
                bookItems = doc.select(".rank-item");
            }
            
            int count = 0;
            for (Element item : bookItems) {
                if (count >= limit) break;
                
                Map<String, Object> novel = new HashMap<>();
                
                try {
                    // 提取排名
                    Element rankElement = item.select(".rank-num").first();
                    if (rankElement == null) {
                        rankElement = item.select(".num").first();
                    }
                    if (rankElement != null) {
                        novel.put("rank", rankElement.text().trim());
                    } else {
                        novel.put("rank", String.valueOf(count + 1));
                    }
                    
                    // 提取书名和链接
                    Element titleElement = item.select("a[title]").first();
                    if (titleElement == null) {
                        titleElement = item.select(".book-name a").first();
                    }
                    if (titleElement == null) {
                        titleElement = item.select(".name a").first();
                    }
                    if (titleElement != null) {
                        novel.put("title", titleElement.attr("title").trim());
                        novel.put("url", "https:" + titleElement.attr("href"));
                    }
                    
                    // 提取作者
                    Element authorElement = item.select(".author").first();
                    if (authorElement == null) {
                        authorElement = item.select(".writer").first();
                    }
                    if (authorElement != null) {
                        novel.put("author", authorElement.text().trim());
                    }
                    
                    // 提取类型
                    Element typeElement = item.select(".type").first();
                    if (typeElement == null) {
                        typeElement = item.select(".category").first();
                    }
                    if (typeElement != null) {
                        novel.put("type", typeElement.text().trim());
                    }
                    
                    // 提取简介
                    Element descElement = item.select(".intro").first();
                    if (descElement == null) {
                        descElement = item.select(".desc").first();
                    }
                    if (descElement != null) {
                        novel.put("description", descElement.text().trim());
                    }
                    
                    // 提取字数
                    Element wordCountElement = item.select(".word-count").first();
                    if (wordCountElement != null) {
                        novel.put("wordCount", wordCountElement.text().trim());
                    }
                    
                    // 如果至少有书名，则添加到结果中
                    if (novel.containsKey("title")) {
                        novels.add(novel);
                        count++;
                    }
                } catch (Exception e) {
                    logger.warn("解析单个小说项时出错: {}", e.getMessage());
                }
            }
            
            // 如果没有解析到任何小说，直接返回空列表
            if (novels.isEmpty()) {
                logger.warn("未能从起点中文网解析到小说数据，网站结构可能已改变或网络连接问题");
            }
            
        } catch (Exception e) {
            logger.error("解析小说排行榜时发生错误", e);
            // 不再返回模拟数据，直接抛出异常让上层处理
            throw new RuntimeException("无法获取小说排行榜数据: " + e.getMessage(), e);
        }
        
        return novels;
    }
    
}